{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "SelectFromModel 是一个基础分类器，其根据重要性权重选择特征。可与拟合后具有coef_或feature_importances_属性的任何估计器一起使用。如果相应的coef_或feature_importances_值低于提供的threshold参数，则这些特征可以认为不重要或者删除。除了指定数值阈值参数，还可以使用字符串参数查找阈值，参数包括：“mean”, “median” 以及这两个参数的浮点数乘积，例如“0.1*mean”。与threshold标准结合使用时，可以通过max_features参数限制选择的特征数量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 多行输出\r\n",
    "from IPython.core.interactiveshell import InteractiveShell\r\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\r\n",
    "import warnings\r\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 1 SelectFromModel基础使用\n",
    "\n",
    "主要参数说明如下：\n",
    "+ threshold：用于特征选择的阈值。保留重要性更高或相等的特征，而其特征则被丢弃。threshold为特征重要性的mean或者median，如果为None，并且估计器的参数惩罚显式或隐式设置为l1（例如Lasso），则使用的阈值为1e-5。否则，默认情况下使用mean。\n",
    "+ prefit：预设模型是否期望直接传递给构造函数。\n",
    "+ norm_order：在估算器threshold的coef_属性为维度2 的情况下，用于过滤以下系数矢量的范数的顺序\n",
    "+ max_features：要选择的最大特征数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "基础使用方法如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimator的模型参数 [[-0.32857694  0.83411609  0.46668853]]\n",
      "用于特征选择的阈值； 0.5431271870420733\n",
      "特征是否保留 [False  True False]\n",
      "特征提取结果 [[-1.34]\n",
      " [-0.02]\n",
      " [-0.48]\n",
      " [ 1.48]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectFromModel\r\n",
    "from sklearn.linear_model import LogisticRegression\r\n",
    "X = [[ 0.87, -1.34,  0.31 ],\r\n",
    "     [-2.79, -0.02, -0.85 ],\r\n",
    "     [-1.34, -0.48, -2.55 ],\r\n",
    "     [ 1.92,  1.48,  0.65 ]]\r\n",
    "y = [0, 1, 0, 1]\r\n",
    "# 建立评估器\r\n",
    "selector = SelectFromModel(estimator=LogisticRegression()).fit(X, y)\r\n",
    "# estimator的模型参数\r\n",
    "print(\"estimator的模型参数\",selector.estimator_.coef_)\r\n",
    "\r\n",
    "# 根据estimator中特征重要性均值获得阈值\r\n",
    "print(\"用于特征选择的阈值；\",selector.threshold_)\r\n",
    "\r\n",
    "# 哪些特征入选最后特征，true表示入选\r\n",
    "print(\"特征是否保留\",selector.get_support())\r\n",
    "# 获得最后结果\r\n",
    "print(\"特征提取结果\",selector.transform(X));\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**下面演示从糖尿病数据集中选择两个最重要的特征，而无需事先知道阈值。**\n",
    "\n",
    "使用SelectFromModel和Lasso回归模型可以从糖尿病数据集中选择最佳的特征。由于L1规范促进了特征的稀疏性，我们可能只对从数据集中选择最有趣特征的子集感兴趣。本示例说明如何从糖尿病数据集中选择两个最有趣的特征。\n",
    "\n",
    "糖尿病数据集由从442名糖尿病患者中收集的10个变量（特征）组成。此示例显示了如何使用SelectFromModel和LassoCv查找预测从基线开始一年后疾病进展的最佳两个特征。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\r\n",
    "import numpy as np\r\n",
    "\r\n",
    "from sklearn.datasets import load_diabetes\r\n",
    "from sklearn.feature_selection import SelectFromModel\r\n",
    "from sklearn.linear_model import LassoCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "首先，让我们加载sklearn中可用的糖尿病数据集。然后，我们将看看为糖尿病患者收集了哪些特征："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']\n"
     ]
    }
   ],
   "source": [
    "diabetes = load_diabetes()\r\n",
    "\r\n",
    "X = diabetes.data\r\n",
    "y = diabetes.target\r\n",
    "\r\n",
    "feature_names = diabetes.feature_names\r\n",
    "print(feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "为了确定功能的重要性，我们将使用LassoCV估计器。具有最高绝对值的特征coef_被认为是最重要的。sklearn中coef_说明见：[https://www.jianshu.com/p/6a818b53a37e](https://www.jianshu.com/p/6a818b53a37e)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "十个特征的重要性： [  0.         226.2375274  526.85738059 314.44026013 196.92164002\n",
      "   1.48742026 151.78054083 106.52846989 530.58541123  64.50588257]\n"
     ]
    }
   ],
   "source": [
    "clf = LassoCV().fit(X, y)\r\n",
    "# 模型参数的绝对值\r\n",
    "importance = np.abs(clf.coef_)\r\n",
    "print(\"十个特征的重要性：\",importance);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "接下来我们可以从具有最高分数的模型特征中过滤特征。现在我们要选择两个最重要特征electFromModel()允许设置阈值。仅保留coef_高于阈值的特征。在这里，我们希望将阈值设置为略高于coef_。LassoCV()根据数据计算出高于第三高特征的高阈值。\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "阈值为 314.4502601292063\n",
      "重要性第三大的特征: ['s5' 'bmi']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SelectFromModel(estimator=LassoCV(alphas=None, copy_X=True, cv='warn', eps=0.001, fit_intercept=True,\n",
       "    max_iter=1000, n_alphas=100, n_jobs=None, normalize=False,\n",
       "    positive=False, precompute='auto', random_state=None,\n",
       "    selection='cyclic', tol=0.0001, verbose=False),\n",
       "        max_features=None, norm_order=1, prefit=False,\n",
       "        threshold=314.4502601292063)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对重要性进行排名\r\n",
    "idx_third = importance.argsort()[-3]\r\n",
    "threshold = importance[idx_third] + 0.01\r\n",
    "print('阈值为',threshold)\r\n",
    "idx_features = (-importance).argsort()[:2]\r\n",
    "name_features = np.array(feature_names)[idx_features]\r\n",
    "print('重要性第三大的特征: {}'.format(name_features))\r\n",
    "\r\n",
    "sfm = SelectFromModel(clf, threshold=threshold);\r\n",
    "sfm.fit(X, y)\r\n",
    "\r\n",
    "# X_transform为特征提取结果\r\n",
    "X_transform = sfm.transform(X)\r\n",
    "# 提取的特征数\r\n",
    "n_features = sfm.transform(X).shape[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "最后，我们将绘制从数据中选择的两个特征。\r\n",
    "\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title(\r\n",
    "    \"Features from diabets using SelectFromModel with \"\r\n",
    "    \"threshold %0.3f.\" % sfm.threshold)\r\n",
    "feature1 = X_transform[:, 0]\r\n",
    "feature2 = X_transform[:, 1]\r\n",
    "plt.plot(feature1, feature2, 'r.')\r\n",
    "plt.xlabel(\"First feature: {}\".format(name_features[0]))\r\n",
    "plt.ylabel(\"Second feature: {}\".format(name_features[1]))\r\n",
    "plt.ylim([np.min(feature2), np.max(feature2)])\r\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 2 SelectFromModel中不同的特征选择方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2.1 基于L1范式进行特征选择\n",
    "用L1范数惩罚的线性模型具有稀疏解：它们的许多估计系数为零。当目标是减少数据的维数以用于另一个分类器时，它们可以与特征一起使用。L1正则化将系数l1范数作为惩罚项添加损失函数上，由于正则项非零，这就迫使那些弱的特征所对应的系数变成0。因此L1正则化往往会使学到的模型很稀疏（系数w经常为0），这个使得L1正则化成为一种常用的征选择方法。特别的用于此目的的稀疏估计量是linear_model.Lasso用于回归，和linear_model.LogisticRegression以及svm.LinearSVC 用于分类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "简单实例如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 4)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(150, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.svm import LinearSVC\r\n",
    "from sklearn.datasets import load_iris\r\n",
    "from sklearn.feature_selection import SelectFromModel\r\n",
    "X, y = load_iris(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "lsvc = LinearSVC(C=0.01, penalty=\"l1\", dual=False).fit(X, y)\r\n",
    "model = SelectFromModel(lsvc, prefit=True)\r\n",
    "X_new = model.transform(X)\r\n",
    "X_new.shape\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "对于SVM和logistic回归，参数C控制稀疏性：C越小，选择的特征就越少。使用Lasso，alpha参数越高，选择的特征就越少。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2.2 基于树的特征选择\n",
    "基于树的评估器可以被用来计算特征的重要性，然后可以根据特征的重要性去除不相关的特征 (当配合sklearn.feature_selection.SelectFromModel meta-transformer):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 4)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征重要性 [0.07293638 0.06131363 0.44503667 0.42071333]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(150, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import ExtraTreesClassifier\r\n",
    "from sklearn.datasets import load_iris\r\n",
    "from sklearn.feature_selection import SelectFromModel\r\n",
    "X, y = load_iris(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "clf = ExtraTreesClassifier(n_estimators=50)\r\n",
    "clf = clf.fit(X, y)\r\n",
    "print(\"特征重要性\",clf.feature_importances_)  \r\n",
    "\r\n",
    "model = SelectFromModel(clf, prefit=True)\r\n",
    "X_new = model.transform(X)\r\n",
    "# 最后保留的特征数\r\n",
    "X_new.shape     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "以下例子展示了如何使用随机森林来评估人工分类任务中特征的重要性。红色柱状表示特征的重要性及标准差。不出所料，该图表明3个特征是有信息的，而其余特征则没有。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature ranking:\n",
      "1. feature 1 (0.295902)\n",
      "2. feature 2 (0.208351)\n",
      "3. feature 0 (0.177632)\n",
      "4. feature 3 (0.047121)\n",
      "5. feature 6 (0.046303)\n",
      "6. feature 8 (0.046013)\n",
      "7. feature 7 (0.045575)\n",
      "8. feature 4 (0.044614)\n",
      "9. feature 9 (0.044577)\n",
      "10. feature 5 (0.043912)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "\r\n",
    "from sklearn.datasets import make_classification\r\n",
    "from sklearn.ensemble import ExtraTreesClassifier\r\n",
    "\r\n",
    "# Build a classification task using 3 informative features\r\n",
    "# 构造一个数据集，特征数为10，但是有效特征只有三个\r\n",
    "X, y = make_classification(n_samples=1000,\r\n",
    "                           n_features=10,\r\n",
    "                           n_informative=3,\r\n",
    "                           n_redundant=0,\r\n",
    "                           n_repeated=0,\r\n",
    "                           n_classes=2,\r\n",
    "                           random_state=0,\r\n",
    "                           shuffle=False)\r\n",
    "\r\n",
    "# Build a forest and compute the impurity-based feature importances\r\n",
    "# 通过随机森林进行分类，并计算各个特征的重要性\r\n",
    "forest = ExtraTreesClassifier(n_estimators=250,\r\n",
    "                              random_state=0)\r\n",
    "\r\n",
    "forest.fit(X, y)\r\n",
    "# 获得重要性\r\n",
    "importances = forest.feature_importances_\r\n",
    "# 计算标准差\r\n",
    "std = np.std([tree.feature_importances_ for tree in forest.estimators_],\r\n",
    "             axis=0)\r\n",
    "indices = np.argsort(importances)[::-1]\r\n",
    "\r\n",
    "# Print the feature ranking\r\n",
    "# 获得特征排名结果\r\n",
    "print(\"Feature ranking:\")\r\n",
    "\r\n",
    "for f in range(X.shape[1]):\r\n",
    "    print(\"%d. feature %d (%f)\" % (f + 1, indices[f], importances[indices[f]]))\r\n",
    "\r\n",
    "# Plot the impurity-based feature importances of the forest\r\n",
    "# 画出各个特征的重要性\r\n",
    "plt.figure()\r\n",
    "plt.title(\"Feature importances\")\r\n",
    "plt.bar(range(X.shape[1]), importances[indices],\r\n",
    "        color=\"r\", yerr=std[indices], align=\"center\")\r\n",
    "plt.xticks(range(X.shape[1]), indices)\r\n",
    "plt.xlim([-1, X.shape[1]]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "以下示例显示了在图像分类任务（面部）中使用随机森林评估像素点中特征的重要性。像素的热值越高，表明该点对于人脸分类越重要。\r\n",
    "\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting ExtraTreesClassifier on faces data with 1 cores...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "ExtraTreesClassifier(bootstrap=False, class_weight=None, criterion='gini',\n",
       "           max_depth=None, max_features=128, max_leaf_nodes=None,\n",
       "           min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "           min_samples_leaf=1, min_samples_split=2,\n",
       "           min_weight_fraction_leaf=0.0, n_estimators=1000, n_jobs=1,\n",
       "           oob_score=False, random_state=0, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done in 1.018s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7feaf2f1f4d0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,1.05,'Pixel importances with forests of trees')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from time import time\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "\r\n",
    "from sklearn.datasets import fetch_olivetti_faces\r\n",
    "from sklearn.ensemble import ExtraTreesClassifier\r\n",
    "\r\n",
    "# Number of cores to use to perform parallel fitting of the forest model\r\n",
    "n_jobs = 1\r\n",
    "\r\n",
    "# Load the faces dataset\r\n",
    "data = fetch_olivetti_faces()\r\n",
    "X, y = data.data, data.target\r\n",
    "\r\n",
    "mask = y < 5  # Limit to 5 classes\r\n",
    "X = X[mask]\r\n",
    "y = y[mask]\r\n",
    "\r\n",
    "# Build a forest and compute the pixel importances\r\n",
    "print(\"Fitting ExtraTreesClassifier on faces data with %d cores...\" % n_jobs)\r\n",
    "t0 = time()\r\n",
    "forest = ExtraTreesClassifier(n_estimators=1000,\r\n",
    "                              max_features=128,\r\n",
    "                              n_jobs=n_jobs,\r\n",
    "                              random_state=0)\r\n",
    "\r\n",
    "forest.fit(X, y)\r\n",
    "print(\"done in %0.3fs\" % (time() - t0))\r\n",
    "# 获得各点的重要性\r\n",
    "importances = forest.feature_importances_\r\n",
    "importances = importances.reshape(data.images[0].shape)\r\n",
    "\r\n",
    "# Plot pixel importances\r\n",
    "plt.matshow(importances, cmap=plt.cm.hot)\r\n",
    "plt.title(\"Pixel importances with forests of trees\")\r\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 3 参考\n",
    "> [https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFromModel.html#sklearn.feature_selection.SelectFromModel](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFromModel.html#sklearn.feature_selection.SelectFromModelhttps://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFromModel.html#sklearn.feature_selection.SelectFromModel)\n",
    "\n",
    "> [https://scikit-learn.org/stable/auto_examples/feature_selection/plot_select_from_model_diabetes.html#sphx-glr-auto-examples-feature-selection-plot-select-from-model-diabetes-py](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_select_from_model_diabetes.html#sphx-glr-auto-examples-feature-selection-plot-select-from-model-diabetes-py)\n",
    "\n",
    "> [https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances.html#sphx-glr-auto-examples-ensemble-plot-forest-importances-py](https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances.html#sphx-glr-auto-examples-ensemble-plot-forest-importances-py)\n",
    "\n",
    "> [https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances_faces.html#sphx-glr-auto-examples-ensemble-plot-forest-importances-faces-py](https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances_faces.html#sphx-glr-auto-examples-ensemble-plot-forest-importances-faces-py)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.8.0 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
